<!DOCTYPE html><html lang="zh-CN"><head>
<meta charset="utf-8"/>
<meta content="width=device-width, initial-scale=1.0" name="viewport"/>
<title>《Python进行数据分析》精简版核心笔记</title>
<style>.container {
    max-width: 800px;
    margin: 0 auto;
    padding: 24px 40px;
    background-color: #fff;
    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
    border-radius: 8px;
    }
.chart-container {
    position: relative;
    margin: 3em auto;
    max-width: 700px;
    min-height: 200px;
    max-height: 400px;
    width: 100%;
    height: auto;
    overflow: visible;
    }
h5 {
    font-size: 16px;
    }
body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Helvetica Neue", "Arial", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
    line-height: 1.8;
    color: #333;
    background-color: #f9f9f9;
    margin: 0 24px 0 24px;
    padding: 0;
    font-size: 16px;
    max-width: None;
    }
h1, h2, h3, h4 {
    color: #1a1a1a;
    border-bottom: 1px solid #eaeaea;
    padding-bottom: 10px;
    margin-top: 24px;
    margin-bottom: 20px;
    font-size: 28px;
    }
h1 {
    font-size: 28px;
    text-align: center;
    border-bottom: 2px solid #007bff;
    margin-top: 24px;
    margin-bottom: 20px;
    }
h2 {
    font-size: 22px;
    border-left: 5px solid #007bff;
    padding-left: 10px;
    }
h3 {
    font-size: 20px;
    }
h4 {
    font-size: 18px;
    border-bottom-style: dashed;
    }
p, li {
    font-size: 16px;
    color: #444;
    }
ul, ol {
    padding-left: 25px;
    }
code {
    font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
    background-color: #f0f0f0;
    padding: 2px 5px;
    border-radius: 4px;
    font-size: 0.9em;
    }
pre {
    background-color: #2d2d2d;
    color: #f8f8f2;
    padding: 15px;
    border-radius: 5px;
    overflow-x: auto;
    white-space: pre-wrap;
    word-wrap: break-word;
    }
pre code {
    background-color: transparent;
    padding: 0;
    font-size: 0.9em;
    line-height: 1.5;
    }
table {
    width: 100%;
    border-collapse: collapse;
    margin: 20px 0;
    }
th, td {
    border: 1px solid #ddd;
    padding: 10px;
    text-align: left;
    }
th {
    background-color: #f2f2f2;
    font-weight: bold;
    }
img {
    max-width: 100%;
    height: auto;
    display: block;
    margin: 1em auto;
    border-radius: 8px;
    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
    overflow: hidden;
    max-height: 280px;
    }
.caption {
    text-align: center;
    font-style: italic;
    color: #666;
    margin-top: -10px;
    margin-bottom: 20px;
    font-size: 0.9em;
    }
.note {
    background-color: #e7f3fe;
    border-left: 6px solid #2196F3;
    padding: 15px;
    margin: 20px 0;
    border-radius: 4px;
    }
.warning {
    background-color: #fffbe6;
    border-left: 6px solid #ffc107;
    padding: 15px;
    margin: 20px 0;
    border-radius: 4px;
    }
.footer {
    text-align: center;
    margin-top: 40px;
    padding-top: 20px;
    border-top: 1px solid #eaeaea;
    font-size: 0.9em;
    color: #888;
    }
@media only screen and (max-device-width: 768px) {
            body {
                padding: 0;
                margin: 0;
                font-family: PingFang SC;
                font-size: 15px;
                line-height: 1.5;
            }

            .container {
                padding: 0;
                margin: 16px 20px 30px;
                box-shadow: none;
            }

            h1,
            h2,
            h3,
            h4 {
                font-family: PingFang SC;
            }

            h1 {
                font-size: 1.87em;
                line-height: 1.6;
                margin-bottom: 0.5em;
                text-align: center;
            }

            h2 {
                font-size: 1.6em;
                font-weight: 600;
                margin-top: 1.3em;
                margin-bottom: 0.8em;
                border-bottom: 1px solid #eee;
                padding-bottom: 0.5em;
            }

            h3 {
                font-size: 1.2em;
                font-weight: 600;
                margin-top: 1em;
                margin-bottom: 0.6em;
            }

            h4 {
                font-size: 1.1em;
                font-weight: 500;
                margin-top: 1em;
                margin-bottom: 0.5em;
                font-style: normal;
            }

            h5 {
                font-size: 1em;
                font-weight: 500;
                margin-bottom: 1.2em;
            }

            ul,
            ol {
                font-size: 1em; /* Equivalent to 17.6px if base is 16px */
                font-weight: 400;
                margin-bottom: 1.2em;
                line-height: 1.8;
            }

            p {
                font-size: 1em;
                line-height: 1.8; /* Equivalent to 17.6px if base is 16px */
                font-weight: 400;
                margin-top: 0.8em;
                margin-bottom: 0.8em;
            }

            blockquote {
                padding: 1em 1.2em;

            p {
                margin: 0;
            }
        }

        figcaption {
            margin-top: 0.5em;
            font-size: 0.8em; /* Equivalent to 17.6px if base is 16px */
            font-weight: 400;
            text-align: center;
            font-style: normal;
            color: #7F8896;
        }

        img {
            display: block;
            overflow: hidden;
            max-width: 100%;
            max-height: 335px;
            margin: 1em auto;
            border-radius: 8px;
        }
        }</style>
<link rel="stylesheet" href="https://static.tiangong.cn/fe/skywork-site-assets/styles/doc_reference_style.css?v=1960664354325233664"/></head>
<body>
<div class="container">
<h1 id="section-1">《Python进行数据分析》精简版核心笔记</h1>
<section id="overview">
<h2 id="section-1">书籍概述与学习路径</h2>
<p>《利用Python进行数据分析》（原书第3版）由pandas库的创建者韦斯·麦金尼（Wes McKinney）撰写，是Python数据分析领域的权威入门教材。本书旨在系统介绍Python编程语言及其在数据分析中广泛使用的库生态和工具，重点在于数据处理、清洗、规整、合并、重塑以及可视化的编程实践，而非深入探讨复杂的数据分析方法论。</p>
<p>本书特别适合希望系统学习Python数据分析的初学者，以及需要将Python作为数据处理工具的从业者。全书强调以 <strong>NumPy</strong> 和 <strong>Pandas</strong> 为核心，进行高效的、面向数组的编程。</p>
<h4>核心技术框架</h4>
<ul>
<li><strong>NumPy</strong>: Python科学计算的基础包，提供高效的多维数组对象 <code>ndarray</code> 及相关运算。</li>
<li><strong>Pandas</strong>: 专为处理表格和异构数据设计，提供 <code>Series</code> 和 <code>DataFrame</code> 两种核心数据结构。</li>
<li><strong>Matplotlib</strong>: 最流行的Python二维数据可视化库，用于创建各种静态、动态、交互式的图表。</li>
<li><strong>IPython 和 Jupyter</strong>: 强大的交互式计算环境，是数据探索和分析的理想工具。</li>
</ul>
<h4>建议学习路径</h4>
<ol>
<li><strong>第1-3章 (基础准备)</strong>: 搭建环境 (Miniconda)，熟悉Python基础语法、数据结构（列表、字典等）、函数以及IPython/Jupyter Notebook的使用。这是后续学习的基石。</li>
<li><strong>第4章 (NumPy核心)</strong>: 深入理解NumPy的 <code>ndarray</code> 对象，掌握数组创建、索引、切片、向量化运算和广播机制。这是理解Pandas底层逻辑的关键。</li>
<li><strong>第5章 (Pandas入门)</strong>: 学习Pandas的 <code>Series</code> 和 <code>DataFrame</code>，这是全书的重点。掌握数据索引、选取、过滤、算术运算、排序和基本统计。</li>
<li><strong>第6章 (数据I/O)</strong>: 学习如何使用Pandas读取和写入各种格式的数据，如CSV、Excel、JSON、HDF5，以及如何与Web API交互。</li>
<li><strong>后续章节 (进阶与实践)</strong>: 在掌握基础后，继续学习数据清洗、规整、聚合、可视化以及时间序列分析，并通过书中的实际案例巩固所学。</li>
</ol>
</section>
<section id="python-basics">
<h2 id="section-2">第2-3章: Python基础与数据结构</h2>
<p>在深入数据分析库之前，必须掌握Python的核心概念。本书第2章和第3章为此打下了坚实的基础。</p>
<h3 id="section-2-1">2.2 IPython 和 Jupyter Notebook</h3>
<p>IPython是增强版的Python解释器，而Jupyter Notebook则提供了一个基于Web的交互式环境，非常适合数据探索。它允许将代码、文本（Markdown）、可视化结果和数学公式整合在一个文档中。</p>
<img alt="Jupyter新建notebook页面" src="https://picture-search.tiangong.cn/image/doc/bec63ba29ed01959fc65ed422895c83c.jpg"/>
<p class="caption">图2-2：Jupyter新建notebook页面</p>
<p>Jupyter的核心特性包括：</p>
<ul>
<li><strong>Tab补全</strong>：自动补全变量名、函数、方法和路径。</li>
<li><strong>自省</strong>：使用问号 <code>?</code> 查看对象文档，<code>??</code> 查看源码。</li>
<li><strong>魔术命令</strong>：以 <code>%</code> 开头的命令，如 <code>%run</code> 执行脚本，<code>%timeit</code> 测试代码性能。</li>
</ul>
<h3 id="section-2-2">3.1 Python核心数据结构</h3>
<p>熟练使用Python内置的数据结构是高效处理数据的前提。</p>
<ul>
<li><strong>元组 (Tuple)</strong>: 长度固定、不可变的序列。常用于函数返回多个值。</li>
<li><strong>列表 (List)</strong>: 长度可变、内容可修改的序列。是Python中最常用的数据结构之一。</li>
<li><strong>字典 (Dict)</strong>: 键值对（key-value）集合，提供高效的查找、插入和删除操作。</li>
<li><strong>集合 (Set)</strong>: 唯一元素的无序集合，支持并集、交集、差集等数学运算。</li>
</ul>
<h4>列表推导式</h4>
<p>列表推导式提供了一种简洁的方式来创建列表，通常比传统的 <code>for</code> 循环更具可读性和效率。</p>
<pre><code># 过滤字符串列表，并转换为大写
strings = [&#34;a&#34;, &#34;as&#34;, &#34;bat&#34;, &#34;car&#34;, &#34;dove&#34;, &#34;python&#34;]
result = [x.upper() for x in strings if len(x) &gt; 2]
# result: [&#39;BAT&#39;, &#39;CAR&#39;, &#39;DOVE&#39;, &#39;PYTHON&#39;]

# 嵌套列表推导式，用于扁平化列表
some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
flattened = [x for tup in some_tuples for x in tup]
# flattened: [1, 2, 3, 4, 5, 6, 7, 8, 9]</code></pre>
</section>
<section id="numpy">
<h2 id="section-3">第4章: NumPy基础：数组和向量化计算</h2>
<p>NumPy是Python数据分析的核心。它提供了高性能的多维数组对象 <code>ndarray</code>，以及用于处理这些数组的工具。NumPy的性能优势源于其C语言实现的底层算法和将数据存储在连续内存块中的能力。</p>
<h3 id="section-3-1">4.1 NumPy的ndarray：多维数组对象</h3>
<p><code>ndarray</code> 是一个通用的同构数据多维容器，即其中所有元素必须是相同类型。每个数组都有一个 <code>shape</code> (表示各维度大小的元组) 和一个 <code>dtype</code> (说明数组数据类型的对象)。</p>
<h4>创建ndarray</h4>
<p>创建数组最简单的方式是使用 <code>np.array</code> 函数，它可以接受任何序列型对象。</p>
<pre><code>import numpy as np

# 从列表创建一维数组
data1 = [6, 7.5, 8, 0, 1]
arr1 = np.array(data1)
# Out: array([6. , 7.5, 8. , 0. , 1. ])

# 从嵌套列表创建二维数组
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)
# Out: array([[1, 2, 3, 4],
#             [5, 6, 7, 8]])

# 查看维度和形状
print(arr2.ndim)  # 2
print(arr2.shape) # (2, 4)

# 其他创建函数
np.zeros((3, 6)) # 创建一个3x6的全0数组
np.ones(10)      # 创建一个长度为10的全1数组
np.arange(15)    # 类似Python的range，但返回ndarray</code></pre>
<h4>NumPy数组的运算（向量化）</h4>
<p>向量化使得我们无需编写循环即可对数据执行批量运算，这比纯Python实现快得多。</p>
<pre><code>arr = np.array([[1., 2., 3.], [4., 5., 6.]])

# 元素级乘法
arr * arr
# Out: array([[ 1.,  4.,  9.],
#             [16., 25., 36.]])

# 数组与标量运算
1 / arr
# Out: array([[1.        , 0.5       , 0.33333333],
#             [0.25      , 0.2       , 0.16666667]])

# 比较运算
arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])
arr2 &gt; arr
# Out: array([[False,  True, False],
#             [ True, False,  True]])</code></pre>
<h3 id="section-3-2">4.1.4 基本的索引和切片</h3>
<p>NumPy数组的索引和切片功能非常强大。与Python列表不同，<strong>数组切片是原始数组的视图</strong>，这意味着数据不会被复制，在视图上的任何修改都会直接反映到源数组上。如果需要副本，必须显式调用 <code>.copy()</code> 方法。</p>
<h4>二维数组索引</h4>
<p>可以传入一个以逗号隔开的索引列表来选取单个元素或子区域。</p>
<img alt="NumPy二维数组中的索引元素" src="https://picture-search.tiangong.cn/image/doc/e60d7ec7459f284e0beabfe1b499f83c.jpg"/>
<p class="caption">图4-1：NumPy二维数组中的索引元素</p>
<pre><code>arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 选取单个元素
arr2d[0, 2]  # 结果为 3

# 切片选取子数组
arr2d[:2, 1:]
# Out: array([[2, 3],
#             [5, 6]])</code></pre>
<img alt="二维数组切片" src="https://picture-search.tiangong.cn/image/doc/ceefc891d4b688e2f49ed101633fa6ea.jpg"/>
<p class="caption">图4-2：二维数组切片示例</p>
<h3 id="section-3-3">4.1.5 布尔型索引</h3>
<p>布尔型索引允许根据条件逻辑选取数组的子集，这是数据清洗和过滤中非常常见的操作。</p>
<pre><code>names = np.array([&#34;Bob&#34;, &#34;Joe&#34;, &#34;Will&#34;, &#34;Bob&#34;, &#34;Will&#34;, &#34;Joe&#34;, &#34;Joe&#34;])
data = np.array([[4, 7], [0, 2], [-5, 6], [0, 0], [1, 2], [-12, -4], [3, 4]])

# 选取所有名字为 &#34;Bob&#34; 的行
data[names == &#34;Bob&#34;]
# Out: array([[4, 7],
#             [0, 0]])

# 使用 &amp; (与) 和 | (或) 组合条件
mask = (names == &#34;Bob&#34;) | (names == &#34;Will&#34;)
data[mask]

# 将所有负值设置为0
data[data &lt; 0] = 0</code></pre>
<h3 id="section-3-4">4.4 利用数组进行面向数组编程</h3>
<p><code>np.where</code> 是三元表达式 <code>x if condition else y</code> 的向量化版本，非常实用。</p>
<pre><code>arr = np.random.standard_normal((4, 4))

# 将所有正值替换为2，负值替换为-2
result = np.where(arr &gt; 0, 2, -2)</code></pre>
<h4>数学和统计方法</h4>
<p>NumPy提供了丰富的数学和统计函数，可以对整个数组或沿某个轴执行计算。</p>
<pre><code>arr = np.random.standard_normal((5, 4))

arr.mean()          # 计算整个数组的平均值
arr.sum()           # 计算整个数组的和
arr.mean(axis=1)    # 计算每行的平均值
arr.sum(axis=0)     # 计算每列的和
arr.cumsum(axis=1)  # 计算每行的累计和</code></pre>
<h3 id="section-3-5">4.7 示例：随机漫步</h3>
<p>这是一个经典的例子，展示了如何用NumPy数组运算来高效地模拟复杂过程。</p>
<pre><code># 模拟一次1000步的随机漫步
nsteps = 1000
rng = np.random.default_rng(seed=12345)
draws = rng.integers(0, 2, size=nsteps)
steps = np.where(draws == 0, 1, -1)
walk = steps.cumsum()

# 找到首次距离起点10步的时刻
(np.abs(walk) &gt;= 10).argmax()</code></pre>
<img alt="一个简单的随机漫步" src="https://picture-search.tiangong.cn/image/doc/c6a12ddca70827fdd25d72dcab5723c4.jpg"/>
<p class="caption">图4-4：一个简单的随机漫步</p>
</section>
<section id="pandas">
<h2 id="section-4">第5章: pandas入门</h2>
<p>Pandas是构建在NumPy之上的库，提供了<code>Series</code>和<code>DataFrame</code>两种核心数据结构，极大地简化了对表格型和异构数据的处理。</p>
<h3 id="section-4-1">5.1 pandas的数据结构</h3>
<h4>Series</h4>
<p><code>Series</code>是一种一维数组型对象，它包含一个值序列和一个与之关联的索引序列。</p>
<pre><code># 创建一个简单的Series
obj = pd.Series([4, 7, -5, 3])

# 创建带自定义索引的Series
obj2 = pd.Series([4, 7, -5, 3], index=[&#34;d&#34;, &#34;b&#34;, &#34;a&#34;, &#34;c&#34;])

# 通过索引选取值
obj2[&#34;a&#34;]  # -5

# 过滤和运算
obj2[obj2 &gt; 0]
np.exp(obj2)

# 从字典创建Series
sdata = {&#34;Ohio&#34;: 35000, &#34;Texas&#34;: 71000, &#34;Oregon&#34;: 16000, &#34;Utah&#34;: 5000}
obj3 = pd.Series(sdata)

# 算术运算时自动对齐索引
obj3 + obj4
# Out:
# California         NaN
# Ohio           70000.0
# Oregon         32000.0
# Texas         142000.0
# Utah               NaN
# dtype: float64</code></pre>
<h4>DataFrame</h4>
<p><code>DataFrame</code>是一个矩形数据表，它含有一组有序的列，每列可以是不同的值类型。它同时有行索引和列索引，可以看作一个共享相同行索引的Series的字典。</p>
<pre><code># 从字典创建DataFrame
data = {&#34;state&#34;: [&#34;Ohio&#34;, &#34;Ohio&#34;, &#34;Ohio&#34;, &#34;Nevada&#34;, &#34;Nevada&#34;, &#34;Nevada&#34;],
        &#34;year&#34;: [2000, 2001, 2002, 2001, 2002, 2003],
        &#34;pop&#34;: [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)

# 查看头部和尾部
frame.head()
frame.tail()

# 选取列
frame[&#34;state&#34;]
frame.year # 仅当列名是合法的Python变量名时可用

# 选取行
frame.loc[1]   # 按标签
frame.iloc[2]  # 按整数位置</code></pre>
<h3 id="section-4-2">5.2 基本功能</h3>
<h4>索引、选取和过滤</h4>
<p>Pandas提供了强大的索引功能，其中 <code>loc</code> 和 <code>iloc</code> 是最核心的工具。</p>
<ul>
<li><code>loc</code>: 基于标签的索引。</li>
<li><code>iloc</code>: 基于整数位置的索引。</li>
</ul>
<div class="note">
<strong>最佳实践</strong>: 为了代码的清晰和避免歧义，尤其是在处理整数索引时，强烈建议使用 <code>.loc</code> 和 <code>.iloc</code> 进行数据选取。
            </div>
<pre><code>data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                    index=[&#34;Ohio&#34;, &#34;Colorado&#34;, &#34;Utah&#34;, &#34;New York&#34;],
                    columns=[&#34;one&#34;, &#34;two&#34;, &#34;three&#34;, &#34;four&#34;])

# 选取单行
data.loc[&#34;Colorado&#34;]

# 同时选取行和列
data.loc[[&#34;Colorado&#34;, &#34;New York&#34;], [&#34;two&#34;, &#34;three&#34;]]

# 使用iloc
data.iloc[2] # 选取第三行
data.iloc[[1, 2], [3, 0, 1]] # 选取第2、3行和第4、1、2列

# 使用布尔条件过滤
data[data[&#34;three&#34;] &gt; 5]</code></pre>
<div class="warning">
<strong>注意链式索引</strong>: 在赋值时应避免使用链式索引，如 <code>data[data.three &gt; 5][&#34;one&#34;] = 0</code>。这可能会在视图上操作而不是原始DataFrame，并产生 <code>SettingWithCopyWarning</code>。正确的做法是使用 <code>.loc</code> 一次性完成索引和赋值：<code>data.loc[data.three &gt; 5, &#34;one&#34;] = 0</code>。
            </div>
<h4>排序和排名</h4>
<pre><code>frame = pd.DataFrame({&#34;b&#34;: [4, 7, -3, 2], &#34;a&#34;: [0, 1, 0, 1]})

# 按值排序
frame.sort_values(by=&#34;b&#34;)

# 按多列排序
frame.sort_values(by=[&#34;a&#34;, &#34;b&#34;])

# 排名
obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
obj.rank(method=&#34;first&#34;) # &#34;first&#34;方法根据出现顺序处理平级关系</code></pre>
<h3 id="section-4-3">5.3 描述性统计的汇总和计算</h3>
<p>Pandas对象拥有一套完整的数学和统计方法，这些方法内置了对缺失数据（NaN）的处理。</p>
<pre><code>df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                   [np.nan, np.nan], [0.75, -1.3]],
                  index=[&#34;a&#34;, &#34;b&#34;, &#34;c&#34;, &#34;d&#34;],
                  columns=[&#34;one&#34;, &#34;two&#34;])

# 求和 (默认跳过NaN)
df.sum() # 按列求和
df.sum(axis=&#34;columns&#34;) # 按行求和

# 生成描述性统计汇总
df.describe()
# Out:
#             one       two
# count  3.000000  2.000000
# mean   3.083333 -2.900000
# std    3.493685  2.262742
# min    0.750000 -4.500000
# 25%    1.075000 -3.700000
# 50%    1.400000 -2.900000
# 75%    4.250000 -2.100000
# max    7.100000 -1.300000</code></pre>
</section>
<section id="data-io">
<h2 id="section-5">第6章: 数据加载、存储与文件格式</h2>
<p>数据分析的第一步通常是加载数据。Pandas提供了强大而灵活的I/O工具。</p>
<h3 id="section-5-1">6.1 读写文本格式的数据</h3>
<p><code>pandas.read_csv</code> 是最常用、功能最丰富的函数，用于读取CSV文件。</p>
<pre><code># 读取一个简单的CSV
df = pd.read_csv(&#34;examples/ex1.csv&#34;)

# 读取没有表头的CSV，并指定列名
pd.read_csv(&#34;examples/ex2.csv&#34;, names=[&#34;a&#34;, &#34;b&#34;, &#34;c&#34;, &#34;d&#34;, &#34;message&#34;])

# 将&#39;message&#39;列作为索引
pd.read_csv(&#34;examples/ex2.csv&#34;, names=names, index_col=&#34;message&#34;)

# 处理不同的分隔符，如空白符
result = pd.read_csv(&#34;examples/ex3.txt&#34;, sep=&#34;\\s+&#34;)

# 处理缺失值
result = pd.read_csv(&#34;examples/ex5.csv&#34;, na_values=[&#34;NULL&#34;])

# 逐块读取大文件
chunker = pd.read_csv(&#34;examples/ex6.csv&#34;, chunksize=1000)
total_counts = pd.Series([], dtype=&#39;int64&#39;)
for piece in chunker:
    total_counts = total_counts.add(piece[&#34;key&#34;].value_counts(), fill_value=0)

# 写入CSV文件
data.to_csv(&#34;examples/out.csv&#34;, index=False, na_rep=&#34;NULL&#34;)</code></pre>
<h3 id="section-5-2">6.1.5 XML 和 HTML: 网络抓取</h3>
<p><code>pandas.read_html</code> 可以方便地从HTML页面中提取表格数据。</p>
<pre><code># 读取HTML页面中的所有表格
tables = pd.read_html(&#34;examples/fdic_failed_bank_list.html&#34;)
failures = tables[0]

# 进行数据分析
close_timestamps = pd.to_datetime(failures[&#34;Closing Date&#34;])
close_timestamps.dt.year.value_counts()</code></pre>
<h3 id="section-5-3">6.2 二进制数据格式</h3>
<p>对于大规模数据，二进制格式通常比文本格式更高效。</p>
<ul>
<li><strong>Pickle</strong>: Python内置的序列化格式，使用 <code>to_pickle</code> 和 <code>read_pickle</code>。适合短期存储。</li>
<li><strong>HDF5</strong>: 一种用于存储大规模科学数组数据的层次型数据格式。Pandas通过 <code>HDFStore</code> 类或 <code>to_hdf</code>/<code>read_hdf</code> 函数提供支持。</li>
<li><strong>Excel</strong>: 使用 <code>read_excel</code> 和 <code>to_excel</code> 读写Excel文件。</li>
</ul>
<h3 id="section-5-4">6.3 与Web API交互</h3>
<p>使用 <code>requests</code> 库可以轻松地与Web API交互，获取JSON等格式的数据，然后用Pandas进行处理。</p>
<pre><code>import requests

url = &#34;https://api.github.com/repos/pandas-dev/pandas/issues&#34;
resp = requests.get(url)
resp.raise_for_status() # 检查请求是否成功

data = resp.json()
issues = pd.DataFrame(data, columns=[&#34;number&#34;, &#34;title&#34;, &#34;labels&#34;, &#34;state&#34;])</code></pre>
</section>
<div class="footer">
<p>内容生成于：2025-08-27</p>
<p>本文档是基于《利用Python进行数据分析》（原书第3版）的精简版学习笔记，旨在提供核心概念和代码的快速参考。</p>
</div>
<div class="reference-container">
			<div class="reference-section">
				<h3 class="reference-title">参考资料</h3>
				<div class="reference-list">
					
					<div class="reference-item">
						<span class="reference-number">[1]</span>
						<div class="reference-content">
							<div class="reference-text-container">
								<span class="reference-text">Python进行数据分析</span>
									
							</div>
							<a href="https://static-recommend-img.tiangong.cn/prod/analysis/2025-08-26/19563742/1960322664669249536_fde017614c1a0d4a1c547c9824ab8126.pdf" class="reference-link" target="_blank">
								https://static-recommend-img.tiangong.cn/prod/analysis/2025-08-26/19563742/1960322664669249536_fde017614c1a0d4a1c547c9824ab8126.pdf
							</a>
						</div>
					</div>
					
				</div>
			</div>
		</div></div>

</body></html>